package org.nox.helloseries.core.services.configuration.tracker.impl;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.nox.helloseries.core.services.configuration.tracker.TrackerConfigurationService;
import org.nox.helloseries.core.util.MarshallingHelper;
import org.nox.helloseries.domain.NomTracker;
import org.nox.helloseries.domain.Tracker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DefaultTrackerConfigurationService implements TrackerConfigurationService
{

    private static final Logger LOG = LoggerFactory.getLogger( DefaultTrackerConfigurationService.class );

    // Initialisation
    private static final String TRACKER_FILE_NAME = "/data/tracker.xml";

    @Override
    public List<Tracker> getTrackers()
    {
        LOG.info( "Récupération du contenu du fichier de configuration" );
        // Récupération du contenu du fichier
        String xmlData = getContenuFichierTracker();

        if ( StringUtils.isNotEmpty( xmlData ) )
        {
            LOG.info( "Marshalling du retour" );
            // Marshalling du fichier
            try
            {

                List<Tracker> trackers = (List<Tracker>) MarshallingHelper.toObject( xmlData );
                LOG.info( trackers.size() + " trackers trouvés en conf" );
                return trackers;
            }
            catch ( ClassCastException e )
            {
                LOG.error( "Fichier de configuration de tracker corrompu" );
            }
        }

        return new ArrayList<>();
    }

    private String getContenuFichierTracker()
    {
        try
        {
            return FileUtils.readFileToString( getTrackerFile() );
        }
        catch ( IOException e )
        {
            LOG.error( "Impossible d'ouvrir le fichier", e );
        }
        return null;
    }

    private File getTrackerFile()
    {
        String path = System.getProperty( "helloseries.home" ) + "/" + TRACKER_FILE_NAME;
        File file = new File( path );
        LOG.debug( "Path du fichier tracker : {}", file.getAbsolutePath() );
        if ( file.exists() )
        {
            LOG.debug( "Path du fichier tracker : {}", file.getAbsolutePath() );
            return file;
        }
        else
        {
            LOG.error( "Fichier de configuration des trackers introuvable : {}", path );
            return null;
        }
    }

    @Override
    public void updateTrackers( List<Tracker> trackersToBeUpdated )
    {
        LOG.info( "Récupération de la liste des trackers" );
        List<Tracker> trackers = getTrackers();
        // Modification de la liste uniquement
        for ( Iterator<Tracker> iterator = trackers.iterator(); iterator.hasNext(); )
        {
            Tracker tracker = (Tracker) iterator.next();

            for ( Tracker trackerToBeUpdated : trackersToBeUpdated )
            {
                // Ce tracker
                if ( trackerToBeUpdated.getNomTracker() == tracker.getNomTracker() )
                {
                    LOG.info( "Maj du tracker " + tracker.getNomTracker() + " à effectuer" );
                    iterator.remove();
                }
            }
        }

        trackers.addAll( trackersToBeUpdated );

        // tri des trackers par prio
        Collections.sort( trackers );

        // Marshalling du fichier & Sauvegarde du fichier
        saveTrackerFile( MarshallingHelper.toXML( trackers ) );

    }

    private void saveTrackerFile( String content )
    {
        try
        {
            FileUtils.writeStringToFile( getTrackerFile(), content );
        }
        catch ( IOException e )
        {
            LOG.error( "Impossible d'ouvrir le fichier", e );
        }
    }

    @Override
    public List<Tracker> getTrackersActifs()
    {
        return (List<Tracker>) CollectionUtils.select( getTrackers(), new Predicate()
        {

            @Override
            public boolean evaluate( Object arg0 )
            {
                return ( (Tracker) arg0 ).isActive();
            }
        } );
    }

    @Override
    public Tracker getTracker( NomTracker nomTracker )
    {
        for ( Tracker tracker : getTrackers() )
        {
            if ( tracker.getNomTracker() == nomTracker )
            {
                return tracker;
            }
        }
        LOG.error( "Tracker " + nomTracker + " non trouvé en conf" );
        return null;
    }
}
